// pages/tjfx/tjfx.js
// 本js中的一些函数使用了async，是因为该函数中需要使用共享环境的云数据库，必须等待init完成 
const app = getApp()

// 本页的全局变量，不能参与wxml的参数传递
var totals = ''  //投放视频的总数 or 未兑换
var pass = ''    //审核“通过”的数量 or 已兑换
var nopass = ''  //审核“未通过”的数量 or 已使用
var yesno = ''  //审核“异常”的数量 or 未使用
var now_year = new Date().getFullYear()
var zhu_day = []
var zhu_week = []
var zhu_week_now = []
var zhu_month = []
var zhu_month_now = []
var canvasInfo = {}

Page({
  data: {
    windowHeight: app.globalData.windowHeight,
    button_flag:true,
    color_toufang:'red',
    color_lvbi:'grey',
    color_day: '',
    color_week: '',
    color_month: '',
    title1:'厨余投放动态',
    title2:'投放数量：个',
    label1:'已投放',
    label2:'已通过',
    label3:'未通过',
    label4:'异常',
  },

  //bottombar菜单点击“回到首页”功能
  gotohome() {
    wx.navigateTo({
      url: '/pages/index/index'
    })
  },
  // bottombar菜单点击“项目抽查”功能
  xmcc() {
    wx.navigateTo({
      url: '/pages/xmcc/xmcc'
    })
  },
  // bottombar菜单点击“库存赠品”功能
  zpkc() {
    wx.navigateTo({
      url: '/pages/zpkc/zpkc'
    })
  },

  // 获取饼图数据
  // 暂未考虑区分社区 
  // 思路1：.geoWithin（db.Geo）
  // 思路2：见《判断当前坐标是否在指定区域》参考代码
  async get_cake() {
    // 声明共享 cloud 实例
    var c1 = new wx.cloud.Cloud({
      // 资源方 AppID
      resourceAppid: 'wxbfd52ca8da22670f',
      // 资源方环境 ID
      resourceEnv: 'cloud1-4gcsxcql7d341258',
    })
    // 跨账号调用，必须等待 init 完成
    // init 过程中，资源方小程序对应环境下的 cloudbase_auth 函数会被调用，并需返回协议字段（见下）来确认允许访问、并可自定义安全规则
    await c1.init()
    var db = c1.database()
    var _ = db.command
    //投放视频的总数量
    db.collection('videoinfo')
      .where({
        name: '厨余投放',
        block:app.globalData.block
      })
      .count().then(res => {
        totals = String(res.total)
      })
    //审核“已通过”视频数量
    db.collection('videoinfo')
      .where({
        name:'厨余投放',
        block:app.globalData.block,
        confirm: '已通过'
      })
      .count().then(res => {
        pass = String(res.total)
      })
    //审核“未通过”视频数量
    db.collection('videoinfo')
      .where({
        name:'厨余投放',
        block:app.globalData.block,
        confirm: '未通过'
      })
      .count().then(res => {
        nopass = String(res.total)
      })
    //审核“异常”视频数量
    db.collection('videoinfo')
      .where({
        name:'厨余投放',
        block:app.globalData.block,
        confirm: '异常'
      })
      .count().then(res => {
        yesno = String(res.total)
      })
  },

  //画饼图
  cake: function () {
    var that = this
    let ctx = null;
    wx.createSelectorQuery()
      .select("#bingtu")
      .context(function (res) {
        // console.log("节点实例：", res); // 节点对应的 Canvas 实例。
        ctx = res.context;
        //已投放or未兑付
        ctx.arc(50, 135, 30, 0, 2 * Math.PI, false)
        ctx.setFillStyle('green')
        ctx.fill()
        ctx.draw()
        // 已通过or已兑付
        ctx.arc(124, 135, 30, 0, 2 * Math.PI, false)
        ctx.setFillStyle('red')
        ctx.fill()
        ctx.draw(true)
        // 未通过or已使用
        ctx.arc(194, 135, 30, 0, 2 * Math.PI, false)
        ctx.setFillStyle('blue')
        ctx.fill()
        ctx.draw(true)
        // 异常or未使用
        ctx.arc(268, 135, 30, 0, 2 * Math.PI, false)
        ctx.setFillStyle('yellow')
        ctx.fill()
        ctx.draw(true)
        //统计数据填充
        ctx.setFontSize(20)
        ctx.setTextAlign('center')
        ctx.setFillStyle('white')
        ctx.fillText(totals, 50, 143)
        ctx.fillText(pass, 124, 143)
        ctx.fillText(nopass, 194, 143)
        ctx.draw(true)
        ctx.setFillStyle('black')
        ctx.fillText(yesno, 268, 143)
        ctx.draw(true)
        // 审核类别标题
        ctx.setFontSize(12)
        ctx.setFillStyle('black')
        ctx.fillText(that.data.label1, 50, 95)
        ctx.fillText(that.data.label2, 124, 95)
        ctx.fillText(that.data.label3, 194, 95)
        ctx.fillText(that.data.label4, 268, 95)
        ctx.draw(true)
        //厨余投放动态 矩形框背景
        ctx.setStrokeStyle('darkgrey')
        ctx.strokeRect(10, 35, 300, 148)
        ctx.draw(true)
        //厨余投放动态 框内标题
        ctx.setFontSize(17)
        ctx.setTextAlign('left')
        ctx.setFillStyle('black')
        ctx.fillText(that.data.title1, 25, 63)
        ctx.draw(true)
      })
      .exec();
  },

  //获得柱状图数据（按日），画柱状图。
  async get_zhu_day() {
    let that = this
    // 声明共享 cloud 实例
    var c1 = new wx.cloud.Cloud({
      // 资源方 AppID
      resourceAppid: 'wxbfd52ca8da22670f',
      // 资源方环境 ID
      resourceEnv: 'cloud1-4gcsxcql7d341258',
    })
    // 跨账号调用，必须等待 init 完成
    // init 过程中，资源方小程序对应环境下的 cloudbase_auth 函数会被调用，并需返回协议字段（见下）来确认允许访问、并可自定义安全规则
    await c1.init()
    var db = c1.database()
    var _ = db.command
    var $ = db.command.aggregate
    db.collection('videoinfo')
      .aggregate()
      .match({
        name:'厨余投放',
        block:app.globalData.block
      })
      .project({
        _id: 0,
        // 增加一个formatDate字段，内容为将原字段date的格式修改为“%Y-%m-%d”
        formatDate: $.dateToString({
          date: '$createtime',
          format: '%Y-%m-%d'
        })
      })
      // 统计相同formatDate的数量
      .group({
        _id: '$formatDate',
        num: $.sum(1)
      })
      // 降序排列
      .sort({
        _id: -1,
      })
      // 前7个统计值
      .limit(7)
      // 再次降序排列
      .sort({
        _id: 1,
      })
      .end()
      .then(res => {
        zhu_day = res.list
        // 画柱状图
        that.zhu(zhu_day)
      })
  },

  //获得柱状图数据（按周）
  async get_zhu_week() {
    let that=this
    // 声明共享 cloud 实例
    var c1 = new wx.cloud.Cloud({
      // 资源方 AppID
      resourceAppid: 'wxbfd52ca8da22670f',
      // 资源方环境 ID
      resourceEnv: 'cloud1-4gcsxcql7d341258',
    })
    // 跨账号调用，必须等待 init 完成
    // init 过程中，资源方小程序对应环境下的 cloudbase_auth 函数会被调用，并需返回协议字段（见下）来确认允许访问、并可自定义安全规则
    await c1.init()
    var db = c1.database()
    var _ = db.command
    var $ = db.command.aggregate
    db.collection('videoinfo')
      .aggregate()
      .match({
        name:'厨余投放',
        block:app.globalData.block
      })
      .project({
        _id: 0,
        // 增加year、week字段
        year: $.year('$createtime'),
        week: $.week('$createtime')
      })
      .match({
        year: now_year
      })
      // 统计相同week的数量
      .group({
        _id: '$week',
        num: $.sum(1)
      })
      .sort({
        _id: -1
      })
      .limit(7)
      .sort({
        _id: 1,
      })
      .end()
      .then(res => {
        zhu_week_now = res.list
        if (zhu_week_now.length < 7) {
          let j = 7 - zhu_week_now.length
          db.collection('videoinfo')
            .aggregate()
            .match({
              name:'厨余投放',
              block:app.globalData.block
            })
            .project({
              _id: 0,
              year: $.year('$createtime'),
              week: $.week('$createtime')
            })
            .match({
              year: now_year - 1
            })
            .group({
              _id: '$week',
              num: $.sum(1)
            })
            .sort({
              _id: -1
            })
            .limit(j)
            .sort({
              _id: 1,
            })
            .end()
            .then(res => {
              zhu_week = res.list
              zhu_week = zhu_week.concat(zhu_week_now)
              that.zhu(zhu_week)
            })
        } else {
          zhu_week = zhu_week_now
          that.zhu(zhu_week)
        }
      })
  },

  //获得柱状图数据（按月）,now_year是整型。
  async get_zhu_month(now_year) {
    let that=this
    // 声明共享 cloud 实例
    var c1 = new wx.cloud.Cloud({
      // 资源方 AppID
      resourceAppid: 'wxbfd52ca8da22670f',
      // 资源方环境 ID
      resourceEnv: 'cloud1-4gcsxcql7d341258',
    })
    // 跨账号调用，必须等待 init 完成
    // init 过程中，资源方小程序对应环境下的 cloudbase_auth 函数会被调用，并需返回协议字段（见下）来确认允许访问、并可自定义安全规则
    await c1.init()
    var db = c1.database()
    var _ = db.command
    var $ = db.command.aggregate
    db.collection('videoinfo')
      .aggregate()
      .match({
        name:'厨余投放',
        block:app.globalData.block
      })
      .project({
        _id: 0,
        year: $.year('$createtime'),
        month: $.month('$createtime')
      })
      .match({
        year: now_year
      })
      .group({
        _id: '$month',
        num: $.sum(1)
      })
      .sort({
        _id: -1
      })
      .limit(7)
      .sort({
        _id: 1,
      })
      .end()
      .then(res => {
        zhu_month_now = res.list
        console.log('zhu_month_now', zhu_month_now)
        console.log(zhu_month_now.length)
        if (zhu_month_now.length < 7) {
          let j = 7 - zhu_month_now.length
          console.log(j)
          db.collection('videoinfo')
            .aggregate()
            .match({
              name:'厨余投放',
              block:app.globalData.block
            })
            .project({
              _id: 0,
              year: $.year('$createtime'),
              month: $.month('$createtime')
            })
            .match({
              year: now_year - 1
            })
            .group({
              _id: '$month',
              num: $.sum(1)
            })
            .sort({
              _id: -1
            })
            .limit(j)
            .sort({
              _id: 1,
            })
            .end()
            .then(res => {
              zhu_month = res.list
              console.log('zhu_month', zhu_month)
              zhu_month = zhu_month.concat(zhu_month_now)
              // 画柱状图
              that.zhu(zhu_month)
            })
        } else {
          zhu_month = zhu_month_now
          that.zhu(zhu_month)
        }
      })
  },

  //获得绿币相关统计数据，包括未兑换、已兑换为使用、已使用的绿币数量。
  async get_lv() {
    let that = this
    let orders_totals = 0
    var c1 = new wx.cloud.Cloud({
      resourceAppid: 'wxbfd52ca8da22670f',
      resourceEnv: 'cloud1-4gcsxcql7d341258',
    })
    await c1.init()
    var db = c1.database()
    var _ = db.command
    var $ = db.command.aggregate
    //获取未兑绿币的总数 userinfo_lvnumber
    db.collection('userinfo')
      .aggregate()
      .match({
        block:app.globalData.block
      })
      .group({
        _id: '$block',
        num: $.sum('$lvnumber')
      })
      .end()
      .then(res => {
        // console.log('lvnumber totals:',res.list.length)
        if(res.list.length != 0){
          totals = String(res.list[0].num)
        }
      })
    //获取已兑绿币的总数 orders_totals
    db.collection('orders')
      .aggregate()
      .match({
        block:app.globalData.block
      })
      .group({
        _id: '$block',
        num: $.sum('$exchange')
      })
      .end()
      .then(res => {
        if(res.list.length != 0){
          orders_totals = res.list[0].num*10
          pass = String(res.list[0].num*10)
        }

        //获取已使用的绿币总数 orders_sign
        db.collection('orders')
          .aggregate()
          .match({
            block: app.globalData.block,
            gettime: _.exists(true)
          })
          .group({
            _id: '$block',
            num: $.sum('$exchange')
          })
          .end()
          .then(res => {
            // console.log('已使用的绿币数量', res.list[0].num)
            if(res.list.length != 0){
              nopass = String(res.list[0].num*10)
              yesno = (orders_totals-(res.list[0].num)*10) //.toFixed(1) 保留1位小数，并转为字符串
            }

            // this.setData({
            //   no_exchange: no_exchange, //函数内如果有data中的同名变量，可以如此简化赋值
            //   no_sign: orders_totals - get_sign,
            //   get_sign: get_sign
            // })
          })
      })
  },

  //建立绿币统计day画图所需的数组，并画柱状图
  async set_datalist_day() {
    var that = this
    var c1 = new wx.cloud.Cloud({
      resourceAppid: 'wxbfd52ca8da22670f',
      resourceEnv: 'cloud1-4gcsxcql7d341258',
    })
    await c1.init()
    var db = c1.database()
    var _ = db.command
    var $ = db.command.aggregate
    var changedata = []
    var signdata = []
    // 获取“已兑换”的绿币统计数据
    let get_change = await db.collection('orders')
      .aggregate()
      .match({
        block:app.globalData.block
      })
      //为便于排序，规范日期格式
      .project({
        _id: 0,
        exchange: 1,
        formatDate: $.dateToString({
          date: '$extime',
          format: '%Y-%m-%d'
        })
      })
      // 统计相同formatDate的数量
      .group({
        _id: '$formatDate',
        num: $.sum('$exchange'),
      })
      // 降序排列
      .sort({
        _id: -1,
      })
      // 前7个统计值
      .limit(7)
      // 再次降序排列
      .sort({
        _id: 1,
      })
      .end()

    // 获取“已使用”的绿币统计数据
    let get_sign = await db.collection('orders')
          .aggregate()
          //过滤没有使用的记录
          .match({
            block:app.globalData.block,
            gettime:_.exists(true)
          })
          // 为便于排序，规范日期格式
          .project({
            _id: 0,
            exchange: 1,
            formatDate: $.dateToString({
              date: '$extime',
              format: '%Y-%m-%d'
            })
          })
          // 统计相同formatDate的数量
          .group({
            _id: '$formatDate',
            have_sign: $.sum('$exchange')
          })
          // 降序排列
          .sort({
            _id: -1,
          })
          // 前7个统计值
          .limit(7)
          // 再次降序排列
          .sort({
            _id: 1,
          })
          .end()
      changedata = get_change.list
      // console.log(changedata)
      signdata = get_sign.list
      // console.log(signdata)
      //将已使用数据填入datalist
      for (let i = 0; i < changedata.length; i++) {
        for (let j = 0; j < signdata.length; j++) {
          if (changedata[i]._id == signdata[j]._id) {
            changedata[i].have_sign = signdata[j].have_sign
          }
        }
        if (!changedata[i].have_sign){
          changedata[i].have_sign = 0
        }
      }
      //画柱状图
      console.log(changedata)
      that.zhu(changedata)
  },

  //获得绿币柱状图数据（按周），并画柱状图
  async set_datalist_week() {
    let that=this
    let get_change = [] //数组中包含：日期_id，已兑绿币数num，使用绿币数have_sign
    var c1 = new wx.cloud.Cloud({
      resourceAppid: 'wxbfd52ca8da22670f',
      resourceEnv: 'cloud1-4gcsxcql7d341258',
    })
    await c1.init()
    var db = c1.database()
    var _ = db.command
    var $ = db.command.aggregate
    db.collection('orders')
      .aggregate()
      .match({
        block:app.globalData.block
      })
      .project({
        _id: 0,
        exchange: 1,
        // 增加year、week字段
        year: $.year('$extime'),
        week: $.week('$extime')
      })
      // year=now_year 
      .match({
        year: now_year
      })
      // 统计相同week的数量
      .group({
        _id: '$week',
        num: $.sum('$exchange')
      })
      .sort({
        _id: -1
      })
      .limit(7)
      .sort({
        _id: 1,
      })
      .end()
      .then(res => {
        zhu_week_now = res.list
        // console.log('now year',zhu_week_now)
        // 获取“已使用”的绿币统计数据
        db.collection('orders')
        .aggregate()
        //过滤没有使用的记录
        .match({
          block:app.globalData.block,
          gettime:_.exists(true)
        })
        .project({
          _id: 0,
          exchange: 1,
          // 增加year、week字段
          year: $.year('$extime'),
          week: $.week('$extime')
        })
        // year=now_year 
        .match({
          year: now_year
        })
        // 统计相同week的数量
        .group({
          _id: '$week',
          have_sign: $.sum('$exchange')
        })
        .sort({
          _id: -1
        })
        .limit(7)
        .sort({
          _id: 1,
        })
        .end()
        .then(res => {
          // console.log('已使用',res)
          for (let i = 0; i < zhu_week_now.length; i++) {
            for (let j = 0; j < res.list.length; j++) {
              if (zhu_week_now[i]._id == res.list[j]._id) {
                zhu_week_now[i].have_sign = res.list[j].have_sign
              }
            }
            if (!zhu_week_now[i].have_sign){
              zhu_week_now[i].have_sign = 0
            }
          }
          if (zhu_week_now.length < 7) {
            let leave = 7 - zhu_week_now.length
            console.log('leave',leave)
            db.collection('orders')
              .aggregate()
              .match({
                block:app.globalData.block
              })
              .project({
                _id: 0,
                exchange: 1,
                year: $.year('$extime'),
                week: $.week('$extime')
              })
              .match({
                year: now_year - 1
              })
              .group({
                _id: '$week',
                num: $.sum('$exchange')
              })
              .sort({
                _id: -1
              })
              .limit(leave)
              .sort({
                _id: 1,
              })
              .end()
              .then(res => {
                zhu_week = res.list
                // console.log('不足周的情况',res)
                // 获取“已使用”的绿币统计数据
                db.collection('orders')
                .aggregate()
                //过滤没有使用的记录
                .match({
                  block:app.globalData.block,
                  gettime:_.exists(true)
                })
                .project({
                  _id: 0,
                  exchange: 1,
                  // 增加year、week字段
                  year: $.year('$extime'),
                  week: $.week('$extime')
                })
                // year=now_year 
                .match({
                  year: now_year - 1
                })
                // 统计相同week的数量
                .group({
                  _id: '$week',
                  have_sign: $.sum('$exchange')
                })
                .sort({
                  _id: -1
                })
                .limit(leave)
                .sort({
                  _id: 1,
                })
                .end()
                .then(res => {
                  console.log('去年的已使用',res)
                  for (let i = 0; i < zhu_week.length; i++) {
                    for (let j = 0; j < res.list.length; j++) {
                      if (zhu_week[i]._id == res.list[j]._id) {
                        zhu_week[i].have_sign = res.list[j].have_sign
                      }
                    }
                    if (!zhu_week[i].have_sign){
                      zhu_week[i].have_sign = 0
                    }
                  }
                  zhu_week = zhu_week.concat(zhu_week_now)
                  for (let i = 0; i < zhu_week.length; i++) {
                    console.log(zhu_week[i]._id,zhu_week[i].num,zhu_week[i].have_sign)
                  }
                  // console.log(zhu_week)
                  that.zhu(zhu_week)
                })
              })
          } else {
            zhu_week = zhu_week_now
            //画柱状图
            that.zhu(zhu_week)
          }
        })
      })
  },

  //获得绿币柱状图数据（按月），并画柱状图
  async set_datalist_month() {
    let that=this
    let get_change = [] //数组中包含：日期_id，已兑绿币数num，使用绿币数have_sign
    var c1 = new wx.cloud.Cloud({
      resourceAppid: 'wxbfd52ca8da22670f',
      resourceEnv: 'cloud1-4gcsxcql7d341258',
    })
    await c1.init()
    var db = c1.database()
    var _ = db.command
    var $ = db.command.aggregate
    db.collection('orders')
      .aggregate()
      .match({
        block:app.globalData.block
      })
      .project({
        _id: 0,
        exchange: 1,
        // 增加year、month字段
        year: $.year('$extime'),
        month: $.month('$extime')
      })
      // year=now_year 
      .match({
        year: now_year
      })
      // 统计相同month的数量
      .group({
        _id: '$month',
        num: $.sum('$exchange')
      })
      .sort({
        _id: -1
      })
      .limit(7)
      .sort({
        _id: 1,
      })
      .end()
      .then(res => {
        zhu_month_now = res.list
        // 获取“已使用”的绿币统计数据
        db.collection('orders')
        .aggregate()
        //过滤没有使用的记录
        .match({
          block:app.globalData.block,
          gettime:_.exists(true)
        })
        .project({
          _id: 0,
          exchange: 1,
          // 增加year、month字段
          year: $.year('$extime'),
          month: $.month('$extime')
        })
        // year=now_year 
        .match({
          year: now_year
        })
        // 统计相同month的数量
        .group({
          _id: '$month',
          have_sign: $.sum('$exchange')
        })
        .sort({
          _id: -1
        })
        .limit(7)
        .sort({
          _id: 1,
        })
        .end()
        .then(res => {
          for (let i = 0; i < zhu_month_now.length; i++) {
            for (let j = 0; j < res.list.length; j++) {
              if (zhu_month_now[i]._id == res.list[j]._id) {
                zhu_month_now[i].have_sign = res.list[j].have_sign
              }
            }
            if (!zhu_month_now[i].have_sign){
              zhu_month_now[i].have_sign = 0
            }
          }
          if (zhu_month_now.length < 7) {
            let leave = 7 - zhu_month_now.length
            db.collection('orders')
              .aggregate()
              .match({
                block:app.globalData.block
              })
              .project({
                _id: 0,
                exchange: 1,
                year: $.year('$extime'),
                month: $.month('$extime')
              })
              .match({
                year: now_year - 1
              })
              .group({
                _id: '$month',
                num: $.sum('$exchange')
              })
              .sort({
                _id: -1
              })
              .limit(leave)
              .sort({
                _id: 1,
              })
              .end()
              .then(res => {
                zhu_month = res.list
                // 获取“已使用”的绿币统计数据
                db.collection('orders')
                .aggregate()
                //过滤没有使用的记录
                .match({
                  block:app.globalData.block,
                  gettime:_.exists(true)
                })
                .project({
                  _id: 0,
                  exchange: 1,
                  // 增加year、month字段
                  year: $.year('$extime'),
                  month: $.month('$extime')
                })
                // year=now_year 
                .match({
                  year: now_year - 1
                })
                // 统计相同month的数量
                .group({
                  _id: '$month',
                  have_sign: $.sum('$exchange')
                })
                .sort({
                  _id: -1
                })
                .limit(leave)
                .sort({
                  _id: 1,
                })
                .end()
                .then(res => {
                  for (let i = 0; i < zhu_month.length; i++) {
                    for (let j = 0; j < res.list.length; j++) {
                      if (zhu_month[i]._id == res.list[j]._id) {
                        zhu_month[i].have_sign = res.list[j].have_sign
                      }
                    }
                    if (!zhu_month[i].have_sign){
                      zhu_month[i].have_sign = 0
                    }
                  }
                  zhu_month = zhu_month.concat(zhu_month_now)
                  that.zhu(zhu_month)
                })

              })
          } else {
            zhu_month = zhu_month_now
            //画柱状图
            that.zhu(zhu_month)
          }
        })
      })
  },

  //画柱状图 dataList为zhu_day，或zhu_week，或zhu_month
  zhu(dataList) {
    var that = this
    let ctx = null;
    let columnarNum = dataList.length
    let columnarWidth = 0
    let maxColumnarHeight = 0
    var maxColumnarValue = 0 //最高金额

    //获取最高金额  maxColumnarValue
    for (var i = 0; i < dataList.length; i++) {
      if (dataList[i].num > maxColumnarValue) {
        maxColumnarValue = dataList[i].num
      }
    }
    // 设置zhu的宽度和高度
    // in() 将选择器的选取范围更改为自定义组件 component 内。
    let query = wx.createSelectorQuery().in(this);
    // boundingClientRect() 获取#zhutu节点的布局位置。相对于显示区域，以像素为单位。
    query.select('#zhutu').boundingClientRect();
    query.exec((res) => {
      canvasInfo.width = res[0].width
      canvasInfo.height = res[0].height
      // 计算柱的宽度
      columnarWidth = (canvasInfo.width - 30) / (2 * columnarNum + 1)
      // 计算高度，扣减上下标签的高度
      maxColumnarHeight = canvasInfo.height - 60 - 20
    })
    //画图准备
    wx.createSelectorQuery()
      .select("#zhutu")
      .context(function (res) {
        // console.log("zhu节点实例：", res); // 节点对应的 Canvas 实例。
        ctx = res.context;
        ctx.setFontSize(15)
        ctx.setFillStyle('rgb(99, 112, 210)')
        ctx.fillText(that.data.title2, 10, 15)
       
        //for 循环，画柱状图
        for (var i = 0; i < dataList.length; i++) {
          //  console.log('have_sign',dataList[i].have_sign)
          ctx.setFontSize(15)
          let dx = columnarWidth * (2 * i + 1)
          let dy = canvasInfo.height - (maxColumnarHeight * (dataList[i].num / maxColumnarValue) + 60) + 10
          ctx.setFillStyle('rgb(99, 112, 210)')
          // 返回文本的宽度
          let valueWidth = ctx.measureText(dataList[i].num + "")
          // 柱端标识具体数值
          ctx.fillText(dataList[i].num + "", dx + columnarWidth / 2 - valueWidth.width / 2, dy + 20)
          // 画柱
          ctx.fillRect(dx, dy + 22, columnarWidth, maxColumnarHeight * (dataList[i].num / maxColumnarValue))
          if(dataList[i].have_sign){
            // console.log(dataList[i].have_sign)
            ctx.setFillStyle('red')
            ctx.fillRect(dx, dy + 22, columnarWidth, maxColumnarHeight * (dataList[i].have_sign / maxColumnarValue))
          }else{
            // console.log('no red',dataList[i].have_sign)
          }
          ctx.setFillStyle('#8a8a8a')
          ctx.setFontSize(12)
          if (dataList[i]._id.length >= 5) {
            // 获取日期文本宽度
            let titleWidth = ctx.measureText(dataList[i]._id.slice(5) + "")
            // 柱底添加日期
            ctx.fillText(dataList[i]._id.slice(5), dx + columnarWidth / 2 - titleWidth.width / 2, canvasInfo.height - 10)
          } else {
            let titleWidth = ctx.measureText(dataList[i]._id + "")
            ctx.fillText(dataList[i]._id, dx + columnarWidth / 2 - titleWidth.width / 2, canvasInfo.height - 10)
          }
        }
        ctx.draw()
      })
      .exec()
  },

  by_day() {
    var that = this
    this.setData({
      color_day: 'black',
      color_week: 'white',
      color_month: 'white'
    })
    if(that.data.button_flag){
      that.get_zhu_day()
    }else{
      that.set_datalist_day()
    }
    
  },

  by_week() {
    var that = this
    this.setData({
      color_day: 'white',
      color_week: 'black',
      color_month: 'white'
    })
    if(that.data.button_flag){
      that.get_zhu_week(now_year)
    }else{
      that.set_datalist_week()
    }
    
  },
  
  by_month() {
    var that = this
    this.setData({
      color_day: 'white',
      color_week: 'white',
      color_month: 'black'
    })
    if(that.data.button_flag){
      this.get_zhu_month(now_year)
    }else{
      that.set_datalist_month()
    }
  },

  //投放统计板块
  tj_toufang(){
    var that = this
    that.data.button_flag = true
    this.setData({
      title1:'厨余投放动态',
      title2:'投放数量：个',
      label1:'已投放',
      label2:'已通过',
      label3:'未通过',
      label4:'异常',
      color_day: 'black',
      color_week: 'white',
      color_month: 'white',
      color_toufang:'red',
      color_lvbi:'grey'
    })
    //获得厨余投放动态的饼图数据
    that.get_cake()
    //画投放统计柱状图（day）
    that.get_zhu_day()
    wx.showLoading({
      title: '加载中',
    })
    setTimeout(function () {
      //画厨余投放动态的饼图
      that.cake()
      wx.hideLoading()
    }, 1500)
  },

  // 绿币统计板块
  tj_lvbi(){
    var that = this
    that.data.button_flag = false
    that.setData({
      title1:'绿币情况概览',
      title2:'已兑金额：元',
      label1:'未兑付',
      label2:'已兑付',
      label3:'已使用',
      label4:'未使用',
      color_day: 'black',
      color_week: 'white',
      color_month: 'white',
      color_toufang:'grey',
      color_lvbi:'red'
    })
    //获得绿币情况概览的数据
    that.get_lv()
    that.set_datalist_day()
    wx.showLoading({
      title: '加载中',
    })
    setTimeout(function () {
      //画绿币情况概览的饼图
      that.cake()
      wx.hideLoading()
    }, 1500)
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    this.tj_toufang()
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady: function () {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow: function () {

  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide: function () {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload: function () {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh: function () {

  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom: function () {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage: function () {

  }
})